// pages/chat/chat.js
const app = getApp()
const apiConfig = require('../../config/api.js')

Page({
  data: {
    messages: [],
    inputValue: '',
    loading: false,
    scrollTop: 0,
    scrollIntoView: '',
    sessions: [],
    currentSessionId: null,
    showSessionList: false,
    
    // 用户头像信息
    userAvatarUrl: '',
    userNickName: '',
    
    // WebSocket长连接相关
    globalSocket: null,
    socketConnected: false,
    socketConnecting: false,
    lastHeartbeat: null,
    
    // AI回答超时配置
    aiResponseTimeout: 300000, // AI回答最大等待时间：5分钟
    currentResponseTimer: null, // 当前回答的计时器
    
    // TTS相关
    ttsEnabled: false,
    ttsAutoPlay: false,
    showTTSSettings: false,
    currentlyPlayingTTS: false,
    ttsStatus: 'disconnected',
    ttsQueueLength: 0,
    
    // 输入框相关
    inputFocus: false,
    keyboardHeight: 0,
    
    // 猜你想问相关
    showGuessQuestions: false,
    showParamInput: false,
    currentQuestion: {},
    selectedDate: '',
    inputText: '',
    selectedZodiac: '',
    selectedZodiacIndex: 0,
    canConfirm: false,
    selectedGender: '',
    selectedGenderIndex: 0,
    genderOptions: ['男', '女'],
    // 日期时间选择器相关
    selectedDateTime: [0, 0, 0, 0, 0], // [年, 月, 日, 时, 分]
    dateTimeRange: [],
    formatDateTime: '',
    zodiacSigns: [
      '白羊座', '金牛座', '双子座', '巨蟹座', '狮子座', '处女座',
      '天秤座', '天蝎座', '射手座', '摩羯座', '水瓶座', '双鱼座'
    ],
    guessQuestions: [
      {
        id: 1,
        icon: '🔮',
        title: '算命',
        description: '预测运势，了解命理',
        template: '请帮我算一下我的运势，我是{gender}性，生日是{date}，想了解近期的事业、感情、财运方面的情况。',
        paramDesc: '请选择您的性别和出生日期，我将根据您的生辰为您分析运势。',
        requiresParam: true,
        paramType: 'fortune',
        supportsProfile: true
      },
      {
        id: 2,
        icon: '🎴',
        title: '占卜',
        description: '塔罗牌占卜指引',
        template: '请为我进行一次塔罗牌占卜，我想了解关于{text}方面的指引和建议。',
        paramDesc: '请详细描述您想要占卜的问题，越具体越好。',
        paramLabel: '您的问题：',
        paramPlaceholder: '例如：我应该换工作吗？感情会有什么发展？',
        requiresParam: true,
        paramType: 'textarea'
      },
      {
        id: 3,
        icon: '📅',
        title: '宜忌',
        description: '今日宜忌查询',
        template: '请帮我查看{date}的宜忌事项，我想了解这一天适合做什么，不适合做什么。',
        paramDesc: '请选择您要查询的日期。',
        requiresParam: true,
        paramType: 'date'
      },
      {
        id: 4,
        icon: '✍️',
        title: '测字',
        description: '汉字测字解析',
        template: '请帮我测字解析，我想测的字是"{text}"，希望了解这个字在我当前情况下的寓意和指引。',
        paramDesc: '请输入您要测的汉字（只能输入一个字）。',
        requiresParam: true,
        paramType: 'text'
      },
      {
        id: 5,
        icon: '🏠',
        title: '风水',
        description: '风水布局建议',
        template: '请为我提供风水建议，我想了解{text}方面的风水知识和改善建议。',
        paramDesc: '请详细描述您的风水问题。',
        paramLabel: '风水问题描述：',
        paramPlaceholder: '例如：客厅沙发应该怎么摆放？卧室床头朝向哪个方向好？',
        requiresParam: true,
        paramType: 'textarea'
      },
      {
        id: 6,
        icon: '💎',
        title: '姓名',
        description: '姓名学分析',
        template: '请帮我分析姓名，我的姓名是"{text}",想了解姓名的寓意、五行属性以及对运势的影响。',
        paramDesc: '请输入您的姓名。',
        requiresParam: true,
        paramType: 'text',
        supportsProfile: true
      },
      {
        id: 7,
        icon: '🌟',
        title: '星座',
        description: '星座运势分析',
        template: '请为我分析星座运势，我是{zodiac}，想了解本周/本月的整体运势和注意事项。',
        paramDesc: '请选择您的星座。',
        requiresParam: true,
        paramType: 'zodiac'
      },
      {
        id: 8,
        icon: '🎯',
        title: '决策',
        description: '人生重要决策指导',
        template: '我面临一个重要决策：{text}，请从命理角度为我提供分析和建议。',
        paramDesc: '请详细描述您面临的选择或困惑。',
        paramLabel: '您的困惑：',
        paramPlaceholder: '例如：我应该接受这个工作机会吗？要不要和现在的对象结婚？',
        requiresParam: true,
        paramType: 'textarea'
      }
    ]
  },

  onLoad(options) {
    console.log('Chat page loaded with options:', options)
    
    this.loadSessions()
    this.loadCurrentSession()
    this.loadTTSSettings()
    this.checkMessageFavoriteStatus()
    
    // 加载用户头像信息
    this.loadUserInfo()
    
    // 加载档案数据
    this.loadProfiles()
    
    // 初始化日期时间选择器
    this.initDateTimeRange()
    
    // 初始化WebSocket长连接
    this.initGlobalWebSocket()
    
    // 如果有传入的会话ID，加载对应会话
    if (options && options.sessionId) {
      this.loadSession({ currentTarget: { dataset: { sessionId: options.sessionId } } })
    }
  },
  
  // 加载用户头像信息
  loadUserInfo() {
    const avatarUrl = wx.getStorageSync('userAvatarUrl')
    const nickName = wx.getStorageSync('userNickName')
    
    this.setData({
      userAvatarUrl: avatarUrl || '',
      userNickName: nickName || '我'
    })
    
    console.log('加载用户信息:', { avatarUrl, nickName })
  },

  // 加载档案数据
  loadProfiles() {
    const profiles = wx.getStorageSync('profiles') || []
    this.setData({
      profiles: profiles
    })
    console.log('加载档案数据:', profiles)
  },

  // 初始化日期时间选择器数据范围
  initDateTimeRange() {
    const now = new Date()
    const currentYear = now.getFullYear()
    
    // 年份范围：1950-2030
    const years = []
    for (let i = 1950; i <= 2030; i++) {
      years.push(i + '年')
    }
    
    // 月份范围：1-12
    const months = []
    for (let i = 1; i <= 12; i++) {
      months.push(i + '月')
    }
    
    // 日期范围：1-31
    const days = []
    for (let i = 1; i <= 31; i++) {
      days.push(i + '日')
    }
    
    // 小时范围：0-23
    const hours = []
    for (let i = 0; i <= 23; i++) {
      hours.push(i.toString().padStart(2, '0') + '时')
    }
    
    // 分钟范围：0-59
    const minutes = []
    for (let i = 0; i <= 59; i++) {
      minutes.push(i.toString().padStart(2, '0') + '分')
    }
    
    this.setData({
      dateTimeRange: [years, months, days, hours, minutes],
      selectedDateTime: [
        currentYear - 1950, // 默认当前年
        now.getMonth(), // 默认当前月
        now.getDate() - 1, // 默认当前日
        now.getHours(), // 默认当前时
        now.getMinutes() // 默认当前分
      ]
    })
    
    this.updateFormatDateTime()
  },

  // 日期时间选择器变化
  onDateTimeChange(e) {
    this.setData({
      selectedDateTime: e.detail.value
    })
    this.updateFormatDateTime()
    // 如果是算命问题，需要检查性别和日期都已选择
    if (this.data.currentQuestion.id === 1) {
      this.checkFortuneCanConfirm()
    } else {
      this.setData({
        canConfirm: true
      })
    }
  },

  // 更新格式化的日期时间
  updateFormatDateTime() {
    const [yearIndex, monthIndex, dayIndex, hourIndex, minuteIndex] = this.data.selectedDateTime
    const year = 1950 + yearIndex
    const month = monthIndex + 1
    const day = dayIndex + 1
    const hour = hourIndex
    const minute = minuteIndex
    
    this.setData({
      formatDateTime: `${year}-${month.toString().padStart(2, '0')}-${day.toString().padStart(2, '0')} ${hour.toString().padStart(2, '0')}:${minute.toString().padStart(2, '0')}`
    })
  },

  onShow() {
    this.scrollToBottom()
    this.checkMessageFavoriteStatus()
    
    // 重新加载用户头像信息，确保与首页同步
    this.loadUserInfo()
    
    // 重新加载档案数据，确保档案创建后能及时更新
    this.loadProfiles()
    
    // 检查WebSocket连接状态，如果未连接则尝试连接
    if (!this.data.socketConnected && !this.data.socketConnecting) {
      console.log('页面显示时检测到WebSocket未连接，尝试重新连接');
      this.initGlobalWebSocket();
    }
  },

  onUnload() {
    // 关闭全局WebSocket连接
    this.closeGlobalWebSocket();
    
    // 页面卸载时的清理工作
    this.stopCurrentTTS();
    
    // 清理心跳定时器
    if (this.heartbeatTimer) {
      clearInterval(this.heartbeatTimer);
      this.heartbeatTimer = null;
    }
    
    // 清理AI回答超时计时器
    if (this.data.currentResponseTimer) {
      clearTimeout(this.data.currentResponseTimer);
      this.setData({ currentResponseTimer: null });
    }
  },

  // 初始化全局WebSocket连接
  initGlobalWebSocket() {
    if (this.data.socketConnecting || this.data.socketConnected) {
      console.log('WebSocket已连接或正在连接中，跳过初始化');
      return;
    }
    
    this.setData({ socketConnecting: true });
    
    const apiBaseUrl = app.getApiBaseUrl();
    const wsUrl = apiBaseUrl.replace(/^https?:\/\//, 'ws://').replace(/^http:\/\//, 'ws://');
    
    console.log('初始化全局WebSocket连接:', `${wsUrl}/chat/ws`);
    
    const socketTask = wx.connectSocket({
      url: `${wsUrl}/chat/ws`,
      timeout: 60000, // 设置连接超时为60秒
      success: () => {
        console.log('全局WebSocket连接创建成功');
      },
      fail: (error) => {
        console.error('全局WebSocket连接创建失败:', error);
        this.setData({ 
          socketConnecting: false,
          socketConnected: false 
        });
      }
    });
    
    // 连接打开事件
    socketTask.onOpen(() => {
      console.log('全局WebSocket连接已建立');
      this.setData({ 
        globalSocket: socketTask,
        socketConnected: true,
        socketConnecting: false,
        lastHeartbeat: Date.now()
      });
      
      // 发送初始session_info
      this.sendSessionInfo();
      
      // 启动心跳
      this.startHeartbeat();
    });
    
    // 连接关闭事件
    socketTask.onClose((res) => {
      console.log('全局WebSocket连接已关闭:', res);
      this.setData({ 
        globalSocket: null,
        socketConnected: false,
        socketConnecting: false 
      });
      
      // 停止心跳
      this.stopHeartbeat();
      
      // 如果不是主动关闭，尝试重连
      if (res.code !== 1000) {
        console.log('WebSocket异常关闭，15秒后尝试重连');
        setTimeout(() => {
          this.initGlobalWebSocket();
        }, 15000); // 延长重连间隔到15秒，给AI更多回答时间
      }
    });
    
    // 连接错误事件
    socketTask.onError((error) => {
      console.error('全局WebSocket连接错误:', error);
      this.setData({ 
        socketConnecting: false,
        socketConnected: false 
      });
    });
    
    // 消息接收事件
    socketTask.onMessage((res) => {
      this.handleGlobalWebSocketMessage(res);
    });
  },
  
  // 关闭全局WebSocket连接
  closeGlobalWebSocket() {
    if (this.data.globalSocket) {
      console.log('主动关闭全局WebSocket连接');
      this.data.globalSocket.close({ code: 1000, reason: 'page unload' });
      this.setData({ 
        globalSocket: null,
        socketConnected: false,
        socketConnecting: false 
      });
    }
    this.stopHeartbeat();
  },
  
  // 发送session_info
  sendSessionInfo() {
    if (!this.data.globalSocket || !this.data.socketConnected) {
      console.log('WebSocket未连接，无法发送session_info');
      return;
    }
    
    const currentSessionId = wx.getStorageSync('current_session_id') || `session_${Date.now()}`;
    const sessionInfo = {
      type: 'session_info',
      session_id: currentSessionId
    };
    
    console.log('发送session_info:', JSON.stringify(sessionInfo));
    
    this.data.globalSocket.send({
      data: JSON.stringify(sessionInfo),
      success: () => {
        console.log('session_info发送成功');
      },
      fail: (error) => {
        console.error('session_info发送失败:', error);
      }
    });
  },
  
  // 启动心跳
  startHeartbeat() {
    this.stopHeartbeat(); // 先停止之前的心跳
    
    this.heartbeatTimer = setInterval(() => {
      if (this.data.globalSocket && this.data.socketConnected) {
        const heartbeat = {
          type: 'ping',
          timestamp: new Date().toISOString()
        };
        
        this.data.globalSocket.send({
          data: JSON.stringify(heartbeat),
          success: () => {
            this.setData({ lastHeartbeat: Date.now() });
            console.log('心跳发送成功');
          },
          fail: (error) => {
            console.error('心跳发送失败:', error);
          }
        });
      }
    }, 120000); // 每2分钟发送一次心跳，减少对AI回答的干扰
  },
  
  // 停止心跳
  stopHeartbeat() {
    if (this.heartbeatTimer) {
      clearInterval(this.heartbeatTimer);
      this.heartbeatTimer = null;
    }
  },
  
  // 处理全局WebSocket消息
  handleGlobalWebSocketMessage(res) {
    try {
      const data = JSON.parse(res.data);
      console.log('收到WebSocket消息:', data);
      
      switch (data.type) {
        case 'session_info':
          console.log('收到session_info:', data);
          if (data.session_id) {
            this.setData({ currentSessionId: data.session_id });
            wx.setStorageSync('current_session_id', data.session_id);
            app.globalData.currentSessionId = data.session_id;
            console.log('会话ID已更新:', data.session_id);
          }
          break;
          
        case 'session_confirmed':
          console.log('会话已确认:', data);
          if (data.session_id) {
            this.setData({ currentSessionId: data.session_id });
            wx.setStorageSync('current_session_id', data.session_id);
            app.globalData.currentSessionId = data.session_id;
            console.log('会话ID已确认并更新:', data.session_id);
          }
          break;
          
        case 'response_chunk':
          this.handleResponseChunk(data);
          break;
          
        case 'response_end':
          console.log('收到response_end，AI文字回答结束');
          // 清除超时计时器
          if (this.data.currentResponseTimer) {
            clearTimeout(this.data.currentResponseTimer);
            this.setData({ currentResponseTimer: null });
          }
          // 结束流式响应状态
          const messages = this.data.messages;
          const lastMessage = messages[messages.length - 1];
          if (lastMessage && lastMessage.type === 'ai' && lastMessage.isStreaming) {
            lastMessage.isStreaming = false;
            this.setData({ messages, loading: false });
            // 保存当前会话
            this.saveCurrentSession();
          }
          break;
          
        case 'tts_start':
          console.log('TTS开始:', data);
          this.setData({ 
            loading: false,
            ttsStatus: 'generating'
          });
          wx.showToast({
            title: '正在生成语音...',
            icon: 'loading',
            duration: 2000
          });
          break;
          
        case 'tts_end':
          console.log('TTS结束:', data);
          this.setData({ ttsStatus: 'ready' });
          if (data.audio_url) {
            this.playAudioFromUrl(data.audio_url);
          }
          break;
          
        case 'tts_error':
          console.error('TTS错误:', data);
          this.setData({ 
            loading: false,
            ttsStatus: 'error'
          });
          wx.showToast({
            title: 'TTS服务异常',
            icon: 'none'
          });
          break;
          
        case 'pong':
          console.log('收到心跳响应');
          this.setData({ lastHeartbeat: Date.now() });
          break;
          
        case 'error':
          console.error('服务器错误:', data);
          this.setData({ loading: false });
          wx.showToast({
            title: data.message || '服务异常',
            icon: 'none'
          });
          break;
          
        default:
          console.log('未知消息类型:', data.type);
          break;
      }
    } catch (error) {
      console.error('解析WebSocket消息失败:', error, res.data);
    }
  },
  
  // 处理响应块
  handleResponseChunk(data) {
    // 收到AI回答的第一个chunk时，清除超时计时器
    if (this.data.currentResponseTimer) {
      clearTimeout(this.data.currentResponseTimer);
      this.setData({ currentResponseTimer: null });
      console.log('收到AI回答，已清除超时计时器');
    }
    
    if (data.content) {
      const messages = this.data.messages;
      const lastMessage = messages[messages.length - 1];
      
      if (lastMessage && lastMessage.type === 'ai' && lastMessage.isStreaming) {
        // 更新流式消息内容
        lastMessage.content += data.content;
        this.setData({ messages });
      } else {
        // 创建新的AI消息
        const aiMessage = {
          id: Date.now(),
          type: 'ai',
          content: data.content,
          timestamp: new Date().toLocaleTimeString(),
          isStreaming: true
        };
        messages.push(aiMessage);
        this.setData({ messages });
      }
      
      // 滚动到底部
      this.scrollToBottom();
    }
    
    if (data.finished) {
      // 流式响应结束
      const messages = this.data.messages;
      const lastMessage = messages[messages.length - 1];
      if (lastMessage && lastMessage.isStreaming) {
        lastMessage.isStreaming = false;
        this.setData({ messages, loading: false });
        // 保存当前会话
        this.saveCurrentSession();
      }
    }
  },
  
  // 通过全局WebSocket发送聊天消息
  sendChatMessage(content) {
    if (!this.data.globalSocket || !this.data.socketConnected) {
      console.log('WebSocket未连接，无法发送聊天消息');
      this.setData({ loading: false });
      wx.showToast({
        title: '连接异常，请重试',
        icon: 'none'
      });
      return;
    }
    
    // 清除之前的超时计时器
    if (this.data.currentResponseTimer) {
      clearTimeout(this.data.currentResponseTimer);
    }
    
    // 构建消息历史
    const messageHistory = this.data.messages
      .filter(msg => msg.type === 'user' || msg.type === 'ai')
      .map(msg => ({
        role: msg.type === 'user' ? 'user' : 'assistant',
        content: msg.content
      }));
    
    const chatData = {
      type: 'chat',
      data: {
        messages: messageHistory,
        query: null,
        audio_output: this.data.ttsEnabled && this.data.ttsAutoPlay
      }
    };
    
    console.log('发送聊天消息:', JSON.stringify(chatData));
    console.log(`AI回答超时设置为: ${this.data.aiResponseTimeout / 1000}秒`);
    
    // 启动AI回答超时计时器
    const responseTimer = setTimeout(() => {
      console.log('AI回答超时，但保持连接继续等待');
      wx.showToast({
        title: 'AI正在深度思考中，请耐心等待...',
        icon: 'none',
        duration: 3000
      });
      // 不断开连接，继续等待AI回答
    }, this.data.aiResponseTimeout);
    
    this.setData({ currentResponseTimer: responseTimer });
    
    this.data.globalSocket.send({
      data: JSON.stringify(chatData),
      success: () => {
        console.log('聊天消息发送成功');
      },
      fail: (error) => {
        console.error('聊天消息发送失败:', error);
        // 清除超时计时器
        if (this.data.currentResponseTimer) {
          clearTimeout(this.data.currentResponseTimer);
          this.setData({ currentResponseTimer: null });
        }
        this.setData({ loading: false });
        wx.showToast({
          title: '发送失败，请重试',
          icon: 'none'
        });
      }
    });
  },

  // 初始化聊天
  initializeChat() {
    const welcomeMessage = {
      id: Date.now(),
      type: 'ai',
      content: '你好！我是神算子AI助手，很高兴为您服务。有什么我可以帮助您的吗？',
      timestamp: new Date().toLocaleTimeString()
    }
    
    this.setData({
      messages: [welcomeMessage]
    })
    
    this.createNewSession()
  },





  // 加载当前会话
  loadCurrentSession() {
    const currentSessionId = wx.getStorageSync('current_session_id')
    if (currentSessionId) {
      // 查找对应的会话数据
      const session = this.data.sessions.find(s => s.id === currentSessionId)
      if (session) {
        // 限制消息数量为最近100条
        const messages = session.messages.slice(-100)
        this.setData({ 
          currentSessionId,
          messages 
        })
        // 同时更新app全局状态
        app.setChatSessionId(currentSessionId)
        console.log('加载当前会话:', currentSessionId, '消息数量:', messages.length)
        this.scrollToBottom()
      } else {
        console.log('会话不存在，创建新会话')
        this.initializeChat()
      }
    } else {
      console.log('没有找到当前会话ID，创建新会话')
      this.initializeChat()
    }
  },

  // 加载会话列表
  loadSessions() {
    const sessions = wx.getStorageSync('chat_sessions') || []
    
    // 为旧会话添加lastUserMessage字段（兼容性处理）
    const updatedSessions = sessions.map(session => {
      if (!session.lastUserMessage) {
        const userMessages = session.messages.filter(msg => msg.type === 'user')
        if (userMessages.length > 0) {
          const lastMessage = userMessages[userMessages.length - 1].content
          session.lastUserMessage = lastMessage.length > 20 ? lastMessage.substring(0, 20) + '...' : lastMessage
        } else {
          session.lastUserMessage = '暂无消息'
        }
      }
      // 格式化时间显示
      session.formattedTime = this.formatTime(session.updatedAt)
      return session
    })
    
    this.setData({ sessions: updatedSessions })
    
    // 如果有更新，保存回storage
    if (updatedSessions.length > 0) {
      wx.setStorageSync('chat_sessions', updatedSessions)
    }
  },

  // 格式化时间显示
  formatTime(isoString) {
    if (!isoString) return ''
    
    const date = new Date(isoString)
    const now = new Date()
    const today = new Date(now.getFullYear(), now.getMonth(), now.getDate())
    const yesterday = new Date(today.getTime() - 24 * 60 * 60 * 1000)
    const sessionDate = new Date(date.getFullYear(), date.getMonth(), date.getDate())
    
    const timeStr = date.toLocaleTimeString('zh-CN', { hour: '2-digit', minute: '2-digit' })
    
    if (sessionDate.getTime() === today.getTime()) {
      return `今天 ${timeStr}`
    } else if (sessionDate.getTime() === yesterday.getTime()) {
      return `昨天 ${timeStr}`
    } else {
      return `${date.getMonth() + 1}/${date.getDate()} ${timeStr}`
    }
  },

  // 加载TTS设置
  loadTTSSettings() {
    const ttsSettings = wx.getStorageSync('tts_settings') || {}
    this.setData({
      ttsEnabled: ttsSettings.enabled || false,
      ttsAutoPlay: ttsSettings.autoPlay || false
    })
  },

  // 保存TTS设置
  saveTTSSettings() {
    const settings = {
      enabled: this.data.ttsEnabled,
      autoPlay: this.data.ttsAutoPlay
    }
    wx.setStorageSync('tts_settings', settings)
  },

  // 创建新会话
  createNewSession() {
    // 先保存当前会话（如果存在）
    if (this.data.currentSessionId && this.data.messages.length > 0) {
      this.saveCurrentSession()
    }
    
    const sessionId = 'session_' + Date.now()
    const now = new Date().toISOString()
    
    // 重置聊天界面
    const welcomeMessage = {
      id: Date.now(),
      type: 'ai',
      content: '你好！我是神算子AI助手，很高兴为您服务。有什么我可以帮助您的吗？',
      timestamp: new Date().toLocaleTimeString()
    }
    
    const session = {
      id: sessionId,
      title: '新对话',
      lastUserMessage: '', // 用于显示在历史会话列表中
      messages: [welcomeMessage],
      createdAt: now,
      updatedAt: now,
      formattedTime: this.formatTime(now)
    }
    
    const sessions = [session, ...this.data.sessions.slice(0, 49)] // 最多保存50个会话
    
    this.setData({
      messages: [welcomeMessage], // 重置消息列表
      currentSessionId: sessionId,
      sessions,
      showSessionList: false,
      inputValue: '', // 清空输入框
      loading: false // 重置加载状态
    })
    
    // 保存会话列表
    wx.setStorageSync('chat_sessions', sessions)
    
    // 保存当前会话ID到storage
    wx.setStorageSync('current_session_id', sessionId)
    
    // 同时更新app全局状态
    app.setChatSessionId(sessionId)
    
    console.log('创建新会话，会话ID:', sessionId)
    this.scrollToBottom()
  },

  // 保存当前会话
  saveCurrentSession() {
    if (!this.data.currentSessionId) return
    
    // 限制消息数量为最近100条
    const limitedMessages = this.data.messages.slice(-100)
    
    const sessions = this.data.sessions.map(session => {
      if (session.id === this.data.currentSessionId) {
        const updatedSession = {
          ...session,
          messages: limitedMessages,
          updatedAt: new Date().toISOString(),
          title: this.generateSessionTitle(),
          lastUserMessage: this.getLastUserMessage()
        }
        updatedSession.formattedTime = this.formatTime(updatedSession.updatedAt)
        return updatedSession
      }
      return session
    })
    
    this.setData({ sessions })
    wx.setStorageSync('chat_sessions', sessions)
  },

  // 生成会话标题
  generateSessionTitle() {
    const userMessages = this.data.messages.filter(msg => msg.type === 'user')
    if (userMessages.length > 0) {
      const firstMessage = userMessages[0].content
      return firstMessage.length > 15 ? firstMessage.substring(0, 15) + '...' : firstMessage
    }
    return '新对话'
  },

  // 获取最后一次用户消息（用于历史会话列表显示）
  getLastUserMessage() {
    const userMessages = this.data.messages.filter(msg => msg.type === 'user')
    if (userMessages.length > 0) {
      const lastMessage = userMessages[userMessages.length - 1].content
      return lastMessage.length > 20 ? lastMessage.substring(0, 20) + '...' : lastMessage
    }
    return '暂无消息'
  },

  // 加载会话
  loadSession(e) {
    const sessionId = e.currentTarget.dataset.sessionId
    const session = this.data.sessions.find(s => s.id === sessionId)
    if (session) {
      // 限制消息数量为最近100条
      const messages = session.messages.slice(-100)
      
      this.setData({
        messages,
        currentSessionId: sessionId,
        showSessionList: false
      })
      
      // 保存当前会话ID到storage
      wx.setStorageSync('current_session_id', sessionId)
      
      // 同时更新app全局状态
      app.setChatSessionId(sessionId)
      
      console.log('切换到会话:', sessionId, '消息数量:', messages.length)
      this.scrollToBottom()
    }
  },

  // 删除会话
  deleteSession(e) {
    const sessionId = e.currentTarget.dataset.sessionId
    console.log('删除会话:', sessionId)
    
    wx.showModal({
      title: '确认删除',
      content: '确定要删除这个会话吗？',
      success: (res) => {
        if (res.confirm) {
          const sessions = this.data.sessions.filter(s => s.id !== sessionId)
          this.setData({ sessions })
          wx.setStorageSync('chat_sessions', sessions)
          
          // 如果删除的是当前会话，需要重置界面
          if (sessionId === this.data.currentSessionId) {
            // 重置为空状态，然后创建新会话
            this.setData({
              messages: [],
              currentSessionId: null,
              inputValue: '',
              loading: false
            })
            // 延迟创建新会话，确保界面已重置
            setTimeout(() => {
              this.createNewSession()
            }, 100)
          }
          
          wx.showToast({
            title: '会话已删除',
            icon: 'success'
          })
        }
      }
    })
  },

  // 发送消息
  sendMessage(e) {
    const content = this.data.inputValue.trim()
    if (!content) {
      wx.showToast({
        title: '请输入消息内容',
        icon: 'none',
        duration: 1500
      })
      return
    }
    
    if (this.data.loading) {
      wx.showToast({
        title: '正在处理中，请稍后',
        icon: 'none',
        duration: 1500
      })
      return
    }
    
    // 检查WebSocket连接状态
    if (!this.data.socketConnected) {
      wx.showToast({
        title: '连接中，请稍候...',
        icon: 'none'
      })
      // 尝试重新连接
      this.initGlobalWebSocket()
      return
    }
    
    const userMessage = {
      id: Date.now(),
      type: 'user',
      content,
      timestamp: new Date().toLocaleTimeString()
    }

    this.setData({
      messages: [...this.data.messages, userMessage],
      inputValue: '',
      loading: true
    }, () => {
      // 检查新消息的收藏状态
      this.checkMessageFavoriteStatus()
    })

    this.scrollToBottom()
    // 使用全局WebSocket发送消息
    this.sendChatMessage(content)
  },

  // 调用聊天API（支持流式响应）
  callChatAPI(message) {
    const apiBaseUrl = app.getApiBaseUrl()
    const sessionId = app.getChatSessionId()
    
    // 准备消息历史
    const messageHistory = this.data.messages.map(msg => ({
      role: msg.type === 'user' ? 'user' : 'assistant',
      content: msg.content
    }))

    // 创建AI消息占位符
    const aiMessageId = Date.now() + 1
    const aiMessage = {
      id: aiMessageId,
      type: 'ai',
      content: '',
      timestamp: new Date().toLocaleTimeString(),
      isStreaming: true
    }
    
    // 添加空的AI消息到列表
    this.setData({
      messages: [...this.data.messages, aiMessage]
    })
    this.scrollToBottom()

    // 尝试使用流式请求
    this.callStreamingAPI(apiBaseUrl, sessionId, messageHistory, aiMessageId)
  },

  // WebSocket API调用
  callStreamingAPI(apiBaseUrl, sessionId, messageHistory, aiMessageId) {
    console.log('开始WebSocket API调用');
    this.callWebSocketAPI(apiBaseUrl, sessionId, messageHistory, aiMessageId);
  },

  // WebSocket连接和通信
  callWebSocketAPI(apiBaseUrl, sessionId, messageHistory, aiMessageId) {
    const that = this;
    
    // 将HTTP URL转换为WebSocket URL
    const wsUrl = apiBaseUrl.replace(/^https?:\/\//, 'ws://').replace(/^http:\/\//, 'ws://');
    
    
    
    // 获取当前会话ID，优先使用storage中的current_session_id
    let currentSessionId = wx.getStorageSync('current_session_id') || sessionId || null;
    console.log('当前会话ID:', currentSessionId);
    
    // 创建WebSocket连接（不再通过请求头传递session_id）
    const socketTask = wx.connectSocket({
      url: `${wsUrl}/chat/ws`,
      success() {
        console.log('WebSocket连接成功');
      },
      fail(error) {
        console.error('WebSocket连接失败:', error);
        console.log('WebSocket连接失败，回退到HTTP请求');
        that.handleWebSocketFailure(aiMessageId);
      }
    });
    
    // 连接打开时先发送session_info，然后发送聊天消息
    socketTask.onOpen(() => {
      console.log('WebSocket连接已打开');
      
      // 首先发送session_info消息
      const sessionInfo = {
        type: 'session_info',
        session_id: currentSessionId || `session_${Date.now()}`
      };
      
      console.log('发送session_info消息:', JSON.stringify(sessionInfo));
      
      socketTask.send({
        data: JSON.stringify(sessionInfo),
        success() {
          console.log('session_info发送成功');
          
          // session_info发送成功后，发送聊天消息
          const chatData = {
            type: 'chat',
            data: {
              messages: messageHistory,
              query: null,
              audio_output: that.data.ttsEnabled && that.data.ttsAutoPlay
            }
          };
          
          console.log('发送聊天消息:', JSON.stringify(chatData));
          
          socketTask.send({
            data: JSON.stringify(chatData),
            success() {
              console.log('聊天消息发送成功');
            },
            fail(error) {
              console.error('聊天消息发送失败:', error);
              that.handleStreamError(aiMessageId);
            }
          });
        },
        fail(error) {
          console.error('session_info发送失败:', error);
          that.handleStreamError(aiMessageId);
        }
      });
    });
    
    // 接收消息
    let accumulatedContent = '';
    socketTask.onMessage((res) => {
      console.log('收到WebSocket消息:', res.data);
      
      try {
        const data = JSON.parse(res.data);
        
        // 会话ID现在通过session_info/session_confirmed消息类型处理
        
        // 处理不同类型的消息
        switch(data.type) {
          case 'session_info':
          case 'session_confirmed':
            if (data.session_id) {
              console.log('收到会话确认，会话ID:', data.session_id);
              // 更新当前会话ID
              currentSessionId = data.session_id;
              // 更新app全局状态
              app.setChatSessionId(data.session_id);
              // 更新storage中的current_session_id
              wx.setStorageSync('current_session_id', data.session_id);
            }
            break;
            
          case 'response_chunk':
            if (data.content) {
              accumulatedContent += data.content;
              that.updateAIMessage(aiMessageId, accumulatedContent, true);
            }
            break;
            
          case 'response_end':
            console.log('收到结束信号:', data);
            that.updateAIMessage(aiMessageId, null, false);
            // 不要立即关闭连接，等待可能的TTS消息
            break;
            
          case 'tts_start':
            console.log('开始语音合成...');
            that.setData({
              ttsStatus: 'generating'
            });
            wx.showToast({
              title: '正在生成语音...',
              icon: 'loading',
              duration: 2000
            });
            break;
            
          case 'tts_end':
            console.log('语音合成完成');
            that.setData({
              ttsStatus: 'ready'
            });
            if (data.audio_url) {
              that.playAudioFromUrl(data.audio_url);
            } else if (data.audio_data) {
              // 兼容旧的base64格式
              that.playServerAudio(data.audio_data);
            }
            // TTS完成后关闭连接
            socketTask.close();
            break;
            
          case 'tts_error':
            console.error('语音合成错误:', data.message);
            that.setData({
              ttsStatus: 'error'
            });
            wx.showToast({
              title: `语音合成失败: ${data.message}`,
              icon: 'none',
              duration: 3000
            });
            socketTask.close();
            break;
            

            
          default:
            // 处理流式内容（兼容旧格式）
            if (data.content) {
              accumulatedContent += data.content;
              that.updateAIMessage(aiMessageId, accumulatedContent, true);
            }
            
            // 检查是否完成（兼容旧格式）
            if (data.done || data.finished || data.finish_reason) {
              console.log('收到结束信号:', data);
              that.updateAIMessage(aiMessageId, null, false);
              socketTask.close();
            }
            break;
        }
      } catch (error) {
        console.error('解析WebSocket消息失败:', error);
        // 尝试直接作为文本处理
        accumulatedContent += res.data;
        that.updateAIMessage(aiMessageId, accumulatedContent, true);
      }
    });
    
    // 处理错误
    socketTask.onError((error) => {
      console.error('WebSocket错误:', error);
      console.log('WebSocket发生错误，回退到HTTP请求');
      

      
      socketTask.close();
      that.handleWebSocketFailure(aiMessageId);
    });
    
    // 处理关闭
    socketTask.onClose((res) => {
      console.log('WebSocket连接已关闭:', res);
      that.updateAIMessage(aiMessageId, null, false);
      

    });
    
    // 保存socket引用以便后续关闭
    this.setData({ currentSocket: socketTask });
    
    // 设置超时
    const timeoutId = setTimeout(() => {
      if (socketTask && socketTask.readyState === 1) { // 只有在连接状态为OPEN时才处理超时
        console.log('WebSocket连接超时，保留已接收内容并结束流式状态');
        
        socketTask.close();
        // 不清空内容，只结束流式状态
        that.updateAIMessage(aiMessageId, null, false);
        
        wx.showToast({
          title: '连接超时，已保留当前回答',
          icon: 'none',
          duration: 2000
        });
      }
    }, 30000); // 30秒超时
    
    // 在连接关闭时清除超时
    const originalOnClose = socketTask.onClose;
    socketTask.onClose = (res) => {
      clearTimeout(timeoutId); // 清除超时定时器
      console.log('WebSocket连接已关闭:', res);
      that.updateAIMessage(aiMessageId, null, false);
    }
  },



  // 更新AI消息内容
  updateAIMessage(messageId, content, isStreaming) {
    const messages = this.data.messages.map(msg => {
      if (msg.id === messageId) {
        const updatedMsg = { ...msg }
        if (content !== null) {
          updatedMsg.content = content
        }
        updatedMsg.isStreaming = isStreaming
        return updatedMsg
      }
      return msg
    })
    
    this.setData({ messages })
    
    if (!isStreaming) {
      this.setData({ loading: false })
      this.scrollToBottom()
      this.saveCurrentSession()
      this.checkMessageFavoriteStatus()
      
      // 注意：现在使用服务端TTS，不需要客户端处理
      console.log('AI消息更新完成，使用服务端TTS处理语音')
    } else {
      this.scrollToBottom()
    }
  },

  // 处理流式错误
  handleStreamError(aiMessageId) {
    this.updateAIMessage(aiMessageId, '抱歉，流式响应处理失败。', false)
  },

  // 处理WebSocket连接失败
  handleWebSocketFailure(aiMessageId) {
    console.log('WebSocket连接失败，显示错误消息');
    this.updateAIMessage(aiMessageId, '网络连接失败，请检查网络后重试。', false);
  },

  // 模拟流式响应（用于测试）
  simulateStreamingResponse(aiMessageId) {
    const testResponse = '这是一个模拟的流式响应，用于测试流式聊天功能是否正常工作。您可以看到文字是逐字显示的效果。'
    let currentIndex = 0
    
    const streamInterval = setInterval(() => {
      if (currentIndex < testResponse.length) {
        const currentContent = testResponse.substring(0, currentIndex + 1)
        this.updateAIMessage(aiMessageId, currentContent, true)
        currentIndex++
      } else {
        clearInterval(streamInterval)
        this.updateAIMessage(aiMessageId, null, false)
      }
    }, 50) // 每50ms显示一个字符
  },

  // 处理API错误
  handleAPIError(res) {
    console.error('API错误:', res)
    this.setData({ loading: false })
    
    let errorMessage = '服务器错误，请稍后重试'
    if (res.statusCode === 429) {
      errorMessage = '请求过于频繁，请稍后重试'
    } else if (res.statusCode === 401) {
      errorMessage = '认证失败，请重新登录'
    }
    
    wx.showToast({
      title: errorMessage,
      icon: 'none'
    })
  },

  // 播放服务端返回的音频URL
  playAudioFromUrl(audioUrl) {
    try {
      console.log('开始播放音频URL:', audioUrl);
      
      // 构建完整的音频URL
       const baseUrl = apiConfig.baseUrl;
       const fullUrl = audioUrl.startsWith('http') ? audioUrl : baseUrl + audioUrl;
      
      console.log('完整音频URL:', fullUrl);
      
      // 创建音频上下文并播放
      const audioContext = wx.createInnerAudioContext();
      audioContext.src = fullUrl;
      
      // 设置播放状态
       this.setData({
         currentlyPlayingTTS: true,
         ttsStatus: 'playing'
       });
      
      audioContext.onPlay(() => {
        console.log('音频开始播放');
        wx.showToast({
          title: '正在播放语音',
          icon: 'none',
          duration: 1000
        });
      });
      
      audioContext.onEnded(() => {
         console.log('音频播放完成');
         audioContext.destroy();
         
         // 更新播放状态
         this.setData({
           currentlyPlayingTTS: false,
           ttsStatus: 'ready'
         });
       });
      
      audioContext.onError((error) => {
         console.error('音频播放失败:', error);
         audioContext.destroy();
         
         // 更新播放状态
         this.setData({
           currentlyPlayingTTS: false,
           ttsStatus: 'error'
         });
         
         wx.showToast({
           title: '音频播放失败',
           icon: 'none',
           duration: 2000
         });
       });
      
      // 开始播放
      audioContext.play();
      
    } catch (error) {
      console.error('处理音频URL失败:', error);
      wx.showToast({
        title: '音频处理失败',
        icon: 'none',
        duration: 2000
      });
    }
  },

  // 播放服务端返回的音频数据（兼容旧格式）
  playServerAudio(base64AudioData) {
    try {
      console.log('开始播放服务端音频数据');
      
      // 将base64数据转换为临时文件
      const fs = wx.getFileSystemManager();
      const tempFilePath = `${wx.env.USER_DATA_PATH}/temp_audio_${Date.now()}.mp3`;
      
      // 写入音频文件
      fs.writeFileSync(tempFilePath, base64AudioData, 'base64');
      
      // 创建音频上下文并播放
      const audioContext = wx.createInnerAudioContext();
      audioContext.src = tempFilePath;
      
      // 设置播放状态
      this.setData({
        currentlyPlayingTTS: true
      });
      
      audioContext.onPlay(() => {
        console.log('音频开始播放');
        wx.showToast({
          title: '正在播放语音',
          icon: 'none',
          duration: 1000
        });
      });
      
      audioContext.onEnded(() => {
        console.log('音频播放完成');
        audioContext.destroy();
        
        // 更新播放状态
        this.setData({
          currentlyPlayingTTS: false
        });
        
        // 清理临时文件
        try {
          fs.unlinkSync(tempFilePath);
        } catch (error) {
          console.warn('清理临时音频文件失败:', error);
        }
      });
      
      audioContext.onError((error) => {
        console.error('音频播放失败:', error);
        audioContext.destroy();
        
        // 更新播放状态
        this.setData({
          currentlyPlayingTTS: false
        });
        
        wx.showToast({
          title: '音频播放失败',
          icon: 'none',
          duration: 2000
        });
        
        // 清理临时文件
        try {
          fs.unlinkSync(tempFilePath);
        } catch (cleanupError) {
          console.warn('清理临时音频文件失败:', cleanupError);
        }
      });
      
      // 开始播放
      audioContext.play();
      
    } catch (error) {
      console.error('处理服务端音频数据失败:', error);
      wx.showToast({
        title: '音频处理失败',
        icon: 'none',
        duration: 2000
      });
    }
  },

  // 语音播放（手动播放文本）
  speakText(e) {
    // 如果是事件对象，从dataset中获取文本
    let text = e
    if (e && e.currentTarget && e.currentTarget.dataset) {
      text = e.currentTarget.dataset.text
    }
    
    if (!this.data.ttsEnabled || !text) {
      console.log('TTS未启用或文本为空')
      return
    }
    
    wx.showToast({
      title: '手动TTS功能已移除，请使用自动播放',
      icon: 'none',
      duration: 2000
    })
  },

  // 停止当前TTS播放
  stopCurrentTTS() {
    console.log('停止当前TTS播放')
    
    // 停止旧的音频播放（兼容性）
    if (this.currentAudioContext) {
      try {
        this.currentAudioContext.stop()
        this.currentAudioContext.destroy()
        this.currentAudioContext = null
        console.log('已停止旧音频播放')
      } catch (error) {
        console.error('停止旧音频播放失败:', error)
      }
    }
    
    if (this.wechatTTSTimer) {
      clearTimeout(this.wechatTTSTimer)
      this.wechatTTSTimer = null
    }
    
    this.setData({
      isSpeaking: false,
      currentlyPlayingTTS: false
    })
    
    wx.showToast({
      title: '语音播放已停止',
      icon: 'success',
      duration: 1500
    })
  },

  // 旧的TTS方法已被新的WebSocket TTS实现替代
  // 保留一些兼容性方法以防需要









  // 输入框相关事件
  onInputChange(e) {
    this.setData({
      inputValue: e.detail.value
    })
  },

  onInputFocus() {
    this.setData({ inputFocus: true })
  },

  onInputBlur() {
    this.setData({ inputFocus: false })
  },

  onKeyboardHeightChange(e) {
    this.setData({
      keyboardHeight: e.detail.height
    })
    if (e.detail.height > 0) {
      setTimeout(() => {
        this.scrollToBottom()
      }, 100)
    }
  },

  // 滚动到底部
  scrollToBottom() {
    setTimeout(() => {
      this.setData({
        scrollIntoView: 'bottom'
      })
    }, 100)
  },

  // 切换会话列表显示
  toggleSessionList() {
    this.setData({
      showSessionList: !this.data.showSessionList
    })
  },

  // 切换TTS设置面板
  toggleTTS() {
    this.setData({
      showTTSSettings: !this.data.showTTSSettings
    })
  },

  // 切换TTS功能
  toggleTTSEnabled(e) {
    const enabled = e.detail.value
    this.setData({
      ttsEnabled: enabled
    })
    
    this.saveTTSSettings()
    
    wx.showToast({
      title: enabled ? 'TTS已启用' : 'TTS已禁用',
      icon: 'success',
      duration: 1500
    })
  },

  toggleTTSAutoPlay(e) {
    const autoPlay = e.detail.value
    this.setData({
      ttsAutoPlay: autoPlay
    })
    
    this.saveTTSSettings()
    
    wx.showToast({
      title: autoPlay ? '自动播放已启用' : '自动播放已禁用',
      icon: 'success',
      duration: 1500
    })
  },



  // 清空TTS队列
  clearTTSQueue() {
    this.stopCurrentTTS()
    this.setData({
      ttsQueueLength: 0
    })
    
    wx.showToast({
      title: '队列已清空',
      icon: 'success',
      duration: 1500
    })
  },



  // 复制消息
  copyMessage(e) {
    const content = e.currentTarget.dataset.content
    wx.setClipboardData({
      data: content,
      success: () => {
        wx.showToast({
          title: '已复制到剪贴板',
          icon: 'success'
        })
      }
    })
  },

  // 收藏消息
  favoriteMessage(e) {
    const content = e.currentTarget.dataset.content
    const messageId = e.currentTarget.dataset.messageId
    
    // 获取已收藏的消息
    let favorites = wx.getStorageSync('favoriteMessages') || []
    
    // 检查是否已收藏
    const isAlreadyFavorited = favorites.some(fav => fav.id === messageId)
    
    if (isAlreadyFavorited) {
      // 取消收藏
      favorites = favorites.filter(fav => fav.id !== messageId)
      wx.showToast({
        title: '已取消收藏',
        icon: 'success'
      })
    } else {
      // 添加收藏
      const favoriteItem = {
        id: messageId,
        content: content,
        timestamp: new Date().toLocaleTimeString(),
        sessionId: this.data.currentSessionId
      }
      favorites.unshift(favoriteItem)
      wx.showToast({
        title: '已添加收藏',
        icon: 'success'
      })
    }
    
    // 保存到本地存储
    wx.setStorageSync('favoriteMessages', favorites)
    
    // 更新消息列表中的收藏状态
    const messages = this.data.messages.map(msg => {
      if (msg.id === messageId) {
        return { ...msg, isFavorited: !isAlreadyFavorited }
      }
      return msg
    })
    
    this.setData({ messages })
  },

  // 检查消息是否已收藏
  checkMessageFavoriteStatus() {
    const favorites = wx.getStorageSync('favoriteMessages') || []
    const favoriteIds = favorites.map(fav => fav.id)
    
    const messages = this.data.messages.map(msg => ({
      ...msg,
      isFavorited: favoriteIds.includes(msg.id)
    }))
    
    this.setData({ messages })
  },

  // 重新生成回答
  regenerateAnswer(e) {
    const messageIndex = e.currentTarget.dataset.index
    const messages = [...this.data.messages]
    
    // 找到对应的用户消息
    if (messageIndex > 0 && messages[messageIndex - 1].type === 'user') {
      // 删除当前AI回答
      messages.splice(messageIndex, 1)
      this.setData({ messages })
      
      // 重新发送请求
      const userMessage = messages[messageIndex - 1].content
      this.callChatAPI(userMessage)
    }
  },

  // 切换猜你想问面板
  toggleGuessQuestions() {
    this.setData({
      showGuessQuestions: !this.data.showGuessQuestions
    })
  },

  // 选择猜你想问的问题
  selectGuessQuestion(e) {
    const questionId = e.currentTarget.dataset.questionId
    const question = this.data.guessQuestions.find(q => q.id === questionId)
    
    if (!question) return
    
    if (question.requiresParam) {
      // 需要参数输入，显示参数输入弹窗
      this.setData({
         currentQuestion: question,
         showParamInput: true,
         showGuessQuestions: false,
         selectedDate: '',
         inputText: '',
         selectedZodiac: '',
         selectedZodiacIndex: 0,
         selectedGender: '',
         selectedGenderIndex: 0,
         canConfirm: false,
         // 重置档案相关状态
         selectedProfile: null,
         showProfileSelector: false,
         useManualInput: false
       })
       
       // 检查是否支持档案选择
       console.log('档案选择检查:', {
         supportsProfile: question.supportsProfile,
         profiles: this.data.profiles,
         profilesLength: this.data.profiles ? this.data.profiles.length : 0
       })
       
       if (question.supportsProfile && this.data.profiles && this.data.profiles.length > 0) {
         // 有档案且问题支持档案，显示档案选择器
         console.log('显示档案选择器')
         this.setData({
           showProfileSelector: true
         })
       } else if (question.supportsProfile && (!this.data.profiles || this.data.profiles.length === 0)) {
         // 支持档案但没有档案，提示用户创建档案
         wx.showModal({
           title: '提示',
           content: '您还没有创建档案，是否前往创建档案？创建档案后可以快速填写信息。',
           confirmText: '去创建',
           cancelText: '手动输入',
           success: (res) => {
             if (res.confirm) {
               console.log('用户选择创建档案，准备跳转')
               // 跳转到档案列表页面并自动打开添加档案弹窗
               wx.navigateTo({
                 url: '/pages/profile-list/profile-list?autoAdd=true',
                 success: () => {
                   console.log('跳转成功')
                 },
                 fail: (err) => {
                   console.error('跳转失败:', err)
                   wx.showToast({
                     title: '跳转失败，请重试',
                     icon: 'none'
                   })
                 }
               })
               // 关闭当前弹窗
               this.setData({
                 showParamInput: false
               })
             } else {
               // 选择手动输入
               this.setData({
                 useManualInput: true
               })
             }
           }
         })
       } else {
         // 不支持档案，直接手动输入
         this.setData({
           useManualInput: true
         })
       }
       
       // 如果是算命问题，重置日期时间选择器
       if (question.id === 1) {
         this.initDateTimeRange()
       }
    } else {
      // 不需要参数，直接使用模板
      this.setData({
        inputValue: question.template,
        showGuessQuestions: false
      })
      
      // 聚焦到输入框
      wx.nextTick(() => {
        this.setData({
          inputFocus: true
        })
      })
    }
  },

  // 关闭参数输入弹窗
   closeParamInput() {
     this.setData({
       showParamInput: false,
       currentQuestion: {},
       selectedDate: '',
       inputText: '',
       selectedZodiac: '',
       selectedZodiacIndex: 0,
       selectedGender: '',
       selectedGenderIndex: 0,
       canConfirm: false,
       formatDateTime: '',
       // 重置档案相关状态
       selectedProfile: null,
       showProfileSelector: false,
       useManualInput: false
     })
   },

  // 日期选择
  onDateChange(e) {
    this.setData({
      selectedDate: e.detail.value,
      canConfirm: true
    })
  },

  // 文本输入
  onTextInput(e) {
    const value = e.detail.value.trim()
    this.setData({
      inputText: value,
      canConfirm: value.length > 0
    })
  },

  // 星座选择
  onZodiacChange(e) {
    const index = e.detail.value
    this.setData({
      selectedZodiacIndex: index,
      selectedZodiac: this.data.zodiacSigns[index],
      canConfirm: true
    })
  },

  // 性别选择
  onGenderChange(e) {
    const index = e.detail.value
    this.setData({
      selectedGenderIndex: index,
      selectedGender: this.data.genderOptions[index]
    })
    this.checkFortuneCanConfirm()
  },

  // 检查算命参数是否完整
  checkFortuneCanConfirm() {
    const hasGender = this.data.selectedGender !== ''
    const hasDateTime = this.data.formatDateTime !== ''
    this.setData({
      canConfirm: hasGender && hasDateTime
    })
  },

  // 选择档案
  selectProfile(e) {
    const profileId = e.currentTarget.dataset.profileId
    const profile = this.data.profiles.find(p => p.id === profileId)
    
    if (!profile) return
    
    const question = this.data.currentQuestion
    let finalTemplate = question.template
    let profileInfo = ''
    
    // 生成档案信息描述
    if (question.id === 1) { // 算命
      profileInfo = `我的姓名是${profile.name}，`
      if (profile.occupation) {
        profileInfo += `职业是${profile.occupation}，`
      }
      if (profile.location) {
        profileInfo += `居住在${profile.location}，`
      }
      
      // 替换模板占位符
      const dateTime = profile.birthDate + (profile.birthTime ? ' ' + profile.birthTime : '')
      finalTemplate = finalTemplate.replace('{gender}', profile.gender || '未知')
      finalTemplate = finalTemplate.replace('{date}', dateTime)
      finalTemplate = finalTemplate.replace('{profileInfo}', profileInfo)
      
    } else if (question.id === 6) { // 姓名分析
      if (profile.birthDate) {
        profileInfo = `我的生日是${profile.birthDate}，`
      }
      if (profile.occupation) {
        profileInfo += `职业是${profile.occupation}，`
      }
      
      // 替换模板占位符
      finalTemplate = finalTemplate.replace('{text}', profile.name)
      finalTemplate = finalTemplate.replace('{profileInfo}', profileInfo)
    }
    
    // 直接设置到输入框并关闭弹窗
    this.setData({
      inputValue: finalTemplate,
      showParamInput: false,
      showProfileSelector: false,
      currentQuestion: {},
      selectedProfile: null,
      useManualInput: false
    })
    
    // 聚焦到输入框
    wx.nextTick(() => {
      this.setData({
        inputFocus: true
      })
    })
  },

  // 选择手动输入
  selectManualInput() {
    this.setData({
      useManualInput: true,
      showProfileSelector: false,
      selectedProfile: null
    })
  },

  // 根据出生日期计算生肖
  calculateZodiac(birthDate) {
    if (!birthDate) return ''
    
    const year = parseInt(birthDate.split('-')[0])
    const zodiacs = ['鼠', '牛', '虎', '兔', '龙', '蛇', '马', '羊', '猴', '鸡', '狗', '猪']
    return zodiacs[(year - 4) % 12]
  },

  // 确认参数输入
   confirmParams() {
    if (!this.data.canConfirm) {
      wx.showToast({
        title: '请完成必填项',
        icon: 'none'
      })
      return
    }

    const question = this.data.currentQuestion
    let finalTemplate = question.template
    let profileInfo = ''

    // 如果使用了档案信息，生成档案描述
    if (this.data.selectedProfile) {
      const profile = this.data.selectedProfile
      if (question.id === 1) { // 算命
        profileInfo = `我的姓名是${profile.name}，`
        if (profile.occupation) {
          profileInfo += `职业是${profile.occupation}，`
        }
        if (profile.location) {
          profileInfo += `居住在${profile.location}，`
        }
      } else if (question.id === 6) { // 姓名
        if (profile.birthDate) {
          profileInfo = `我的生日是${profile.birthDate}，`
        }
        if (profile.occupation) {
          profileInfo += `职业是${profile.occupation}，`
        }
      }
    }

    // 根据参数类型替换模板中的占位符
     switch (question.paramType) {
       case 'fortune':
         // 算命需要性别和日期时间
         finalTemplate = finalTemplate.replace('{gender}', this.data.selectedGender)
         finalTemplate = finalTemplate.replace('{date}', this.data.formatDateTime)
         finalTemplate = finalTemplate.replace('{profileInfo}', profileInfo)
         break
       case 'date':
         if (question.id === 1) {
           // 算命使用精确到分钟的日期时间
           finalTemplate = finalTemplate.replace('{date}', this.data.formatDateTime)
         } else {
           // 其他使用普通日期
           finalTemplate = finalTemplate.replace('{date}', this.data.selectedDate)
         }
         break
       case 'text':
         finalTemplate = finalTemplate.replace('{text}', this.data.inputText)
         if (question.supportsProfile) {
           finalTemplate = finalTemplate.replace('{profileInfo}', profileInfo)
         }
         break
       case 'textarea':
         finalTemplate = finalTemplate.replace('{text}', this.data.inputText)
         break
       case 'zodiac':
         finalTemplate = finalTemplate.replace('{zodiac}', this.data.selectedZodiac)
         break
     }

    // 设置到输入框并关闭弹窗
     this.setData({
       inputValue: finalTemplate,
       showParamInput: false,
       currentQuestion: {},
       selectedDate: '',
       inputText: '',
       selectedZodiac: '',
       selectedZodiacIndex: 0,
       selectedGender: '',
       selectedGenderIndex: 0,
       canConfirm: false,
       formatDateTime: '',
       selectedProfile: null,
       showProfileSelector: false,
       useManualInput: false
     })

    // 聚焦到输入框
    wx.nextTick(() => {
      this.setData({
        inputFocus: true
      })
    })
  }
})